home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / usr / include / linux / fuse.h < prev    next >
C/C++ Source or Header  |  2008-10-24  |  7KB  |  412 lines
  1. /*
  2.     FUSE: Filesystem in Userspace
  3.     Copyright (C) 2001-2006  Miklos Szeredi <miklos@szeredi.hu>
  4.  
  5.     This program can be distributed under the terms of the GNU GPL.
  6.     See the file COPYING.
  7. */
  8.  
  9. /*
  10.  * This file defines the kernel interface of FUSE
  11.  *
  12.  * Protocol changelog:
  13.  *
  14.  * 7.9:
  15.  *  - new fuse_getattr_in input argument of GETATTR
  16.  *  - add lk_flags in fuse_lk_in
  17.  *  - add lock_owner field to fuse_setattr_in, fuse_read_in and fuse_write_in
  18.  *  - add blksize field to fuse_attr
  19.  *  - add file flags field to fuse_read_in and fuse_write_in
  20.  */
  21.  
  22. #include <asm/types.h>
  23. #include <linux/major.h>
  24.  
  25. /** Version number of this interface */
  26. #define FUSE_KERNEL_VERSION 7
  27.  
  28. /** Minor version number of this interface */
  29. #define FUSE_KERNEL_MINOR_VERSION 9
  30.  
  31. /** The node ID of the root inode */
  32. #define FUSE_ROOT_ID 1
  33.  
  34. /** The major number of the fuse character device */
  35. #define FUSE_MAJOR MISC_MAJOR
  36.  
  37. /** The minor number of the fuse character device */
  38. #define FUSE_MINOR 229
  39.  
  40. /* Make sure all structures are padded to 64bit boundary, so 32bit
  41.    userspace works under 64bit kernels */
  42.  
  43. struct fuse_attr {
  44.     __u64    ino;
  45.     __u64    size;
  46.     __u64    blocks;
  47.     __u64    atime;
  48.     __u64    mtime;
  49.     __u64    ctime;
  50.     __u32    atimensec;
  51.     __u32    mtimensec;
  52.     __u32    ctimensec;
  53.     __u32    mode;
  54.     __u32    nlink;
  55.     __u32    uid;
  56.     __u32    gid;
  57.     __u32    rdev;
  58.     __u32    blksize;
  59.     __u32    padding;
  60. };
  61.  
  62. struct fuse_kstatfs {
  63.     __u64    blocks;
  64.     __u64    bfree;
  65.     __u64    bavail;
  66.     __u64    files;
  67.     __u64    ffree;
  68.     __u32    bsize;
  69.     __u32    namelen;
  70.     __u32    frsize;
  71.     __u32    padding;
  72.     __u32    spare[6];
  73. };
  74.  
  75. struct fuse_file_lock {
  76.     __u64    start;
  77.     __u64    end;
  78.     __u32    type;
  79.     __u32    pid; /* tgid */
  80. };
  81.  
  82. /**
  83.  * Bitmasks for fuse_setattr_in.valid
  84.  */
  85. #define FATTR_MODE    (1 << 0)
  86. #define FATTR_UID    (1 << 1)
  87. #define FATTR_GID    (1 << 2)
  88. #define FATTR_SIZE    (1 << 3)
  89. #define FATTR_ATIME    (1 << 4)
  90. #define FATTR_MTIME    (1 << 5)
  91. #define FATTR_FH    (1 << 6)
  92. #define FATTR_ATIME_NOW    (1 << 7)
  93. #define FATTR_MTIME_NOW    (1 << 8)
  94. #define FATTR_LOCKOWNER    (1 << 9)
  95.  
  96. /**
  97.  * Flags returned by the OPEN request
  98.  *
  99.  * FOPEN_DIRECT_IO: bypass page cache for this open file
  100.  * FOPEN_KEEP_CACHE: don't invalidate the data cache on open
  101.  */
  102. #define FOPEN_DIRECT_IO        (1 << 0)
  103. #define FOPEN_KEEP_CACHE    (1 << 1)
  104.  
  105. /**
  106.  * INIT request/reply flags
  107.  *
  108.  * FUSE_EXPORT_SUPPORT: filesystem handles lookups of "." and ".."
  109.  */
  110. #define FUSE_ASYNC_READ        (1 << 0)
  111. #define FUSE_POSIX_LOCKS    (1 << 1)
  112. #define FUSE_FILE_OPS        (1 << 2)
  113. #define FUSE_ATOMIC_O_TRUNC    (1 << 3)
  114. #define FUSE_EXPORT_SUPPORT    (1 << 4)
  115. #define FUSE_BIG_WRITES        (1 << 5)
  116.  
  117. /**
  118.  * Release flags
  119.  */
  120. #define FUSE_RELEASE_FLUSH    (1 << 0)
  121.  
  122. /**
  123.  * Getattr flags
  124.  */
  125. #define FUSE_GETATTR_FH        (1 << 0)
  126.  
  127. /**
  128.  * Lock flags
  129.  */
  130. #define FUSE_LK_FLOCK        (1 << 0)
  131.  
  132. /**
  133.  * WRITE flags
  134.  *
  135.  * FUSE_WRITE_CACHE: delayed write from page cache, file handle is guessed
  136.  * FUSE_WRITE_LOCKOWNER: lock_owner field is valid
  137.  */
  138. #define FUSE_WRITE_CACHE    (1 << 0)
  139. #define FUSE_WRITE_LOCKOWNER    (1 << 1)
  140.  
  141. /**
  142.  * Read flags
  143.  */
  144. #define FUSE_READ_LOCKOWNER    (1 << 1)
  145.  
  146. enum fuse_opcode {
  147.     FUSE_LOOKUP       = 1,
  148.     FUSE_FORGET       = 2,  /* no reply */
  149.     FUSE_GETATTR       = 3,
  150.     FUSE_SETATTR       = 4,
  151.     FUSE_READLINK       = 5,
  152.     FUSE_SYMLINK       = 6,
  153.     FUSE_MKNOD       = 8,
  154.     FUSE_MKDIR       = 9,
  155.     FUSE_UNLINK       = 10,
  156.     FUSE_RMDIR       = 11,
  157.     FUSE_RENAME       = 12,
  158.     FUSE_LINK       = 13,
  159.     FUSE_OPEN       = 14,
  160.     FUSE_READ       = 15,
  161.     FUSE_WRITE       = 16,
  162.     FUSE_STATFS       = 17,
  163.     FUSE_RELEASE       = 18,
  164.     FUSE_FSYNC         = 20,
  165.     FUSE_SETXATTR      = 21,
  166.     FUSE_GETXATTR      = 22,
  167.     FUSE_LISTXATTR     = 23,
  168.     FUSE_REMOVEXATTR   = 24,
  169.     FUSE_FLUSH         = 25,
  170.     FUSE_INIT          = 26,
  171.     FUSE_OPENDIR       = 27,
  172.     FUSE_READDIR       = 28,
  173.     FUSE_RELEASEDIR    = 29,
  174.     FUSE_FSYNCDIR      = 30,
  175.     FUSE_GETLK         = 31,
  176.     FUSE_SETLK         = 32,
  177.     FUSE_SETLKW        = 33,
  178.     FUSE_ACCESS        = 34,
  179.     FUSE_CREATE        = 35,
  180.     FUSE_INTERRUPT     = 36,
  181.     FUSE_BMAP          = 37,
  182.     FUSE_DESTROY       = 38,
  183. };
  184.  
  185. /* The read buffer is required to be at least 8k, but may be much larger */
  186. #define FUSE_MIN_READ_BUFFER 8192
  187.  
  188. #define FUSE_COMPAT_ENTRY_OUT_SIZE 120
  189.  
  190. struct fuse_entry_out {
  191.     __u64    nodeid;        /* Inode ID */
  192.     __u64    generation;    /* Inode generation: nodeid:gen must
  193.                    be unique for the fs's lifetime */
  194.     __u64    entry_valid;    /* Cache timeout for the name */
  195.     __u64    attr_valid;    /* Cache timeout for the attributes */
  196.     __u32    entry_valid_nsec;
  197.     __u32    attr_valid_nsec;
  198.     struct fuse_attr attr;
  199. };
  200.  
  201. struct fuse_forget_in {
  202.     __u64    nlookup;
  203. };
  204.  
  205. struct fuse_getattr_in {
  206.     __u32    getattr_flags;
  207.     __u32    dummy;
  208.     __u64    fh;
  209. };
  210.  
  211. #define FUSE_COMPAT_ATTR_OUT_SIZE 96
  212.  
  213. struct fuse_attr_out {
  214.     __u64    attr_valid;    /* Cache timeout for the attributes */
  215.     __u32    attr_valid_nsec;
  216.     __u32    dummy;
  217.     struct fuse_attr attr;
  218. };
  219.  
  220. struct fuse_mknod_in {
  221.     __u32    mode;
  222.     __u32    rdev;
  223. };
  224.  
  225. struct fuse_mkdir_in {
  226.     __u32    mode;
  227.     __u32    padding;
  228. };
  229.  
  230. struct fuse_rename_in {
  231.     __u64    newdir;
  232. };
  233.  
  234. struct fuse_link_in {
  235.     __u64    oldnodeid;
  236. };
  237.  
  238. struct fuse_setattr_in {
  239.     __u32    valid;
  240.     __u32    padding;
  241.     __u64    fh;
  242.     __u64    size;
  243.     __u64    lock_owner;
  244.     __u64    atime;
  245.     __u64    mtime;
  246.     __u64    unused2;
  247.     __u32    atimensec;
  248.     __u32    mtimensec;
  249.     __u32    unused3;
  250.     __u32    mode;
  251.     __u32    unused4;
  252.     __u32    uid;
  253.     __u32    gid;
  254.     __u32    unused5;
  255. };
  256.  
  257. struct fuse_open_in {
  258.     __u32    flags;
  259.     __u32    mode;
  260. };
  261.  
  262. struct fuse_open_out {
  263.     __u64    fh;
  264.     __u32    open_flags;
  265.     __u32    padding;
  266. };
  267.  
  268. struct fuse_release_in {
  269.     __u64    fh;
  270.     __u32    flags;
  271.     __u32    release_flags;
  272.     __u64    lock_owner;
  273. };
  274.  
  275. struct fuse_flush_in {
  276.     __u64    fh;
  277.     __u32    unused;
  278.     __u32    padding;
  279.     __u64    lock_owner;
  280. };
  281.  
  282. struct fuse_read_in {
  283.     __u64    fh;
  284.     __u64    offset;
  285.     __u32    size;
  286.     __u32    read_flags;
  287.     __u64    lock_owner;
  288.     __u32    flags;
  289.     __u32    padding;
  290. };
  291.  
  292. #define FUSE_COMPAT_WRITE_IN_SIZE 24
  293.  
  294. struct fuse_write_in {
  295.     __u64    fh;
  296.     __u64    offset;
  297.     __u32    size;
  298.     __u32    write_flags;
  299.     __u64    lock_owner;
  300.     __u32    flags;
  301.     __u32    padding;
  302. };
  303.  
  304. struct fuse_write_out {
  305.     __u32    size;
  306.     __u32    padding;
  307. };
  308.  
  309. #define FUSE_COMPAT_STATFS_SIZE 48
  310.  
  311. struct fuse_statfs_out {
  312.     struct fuse_kstatfs st;
  313. };
  314.  
  315. struct fuse_fsync_in {
  316.     __u64    fh;
  317.     __u32    fsync_flags;
  318.     __u32    padding;
  319. };
  320.  
  321. struct fuse_setxattr_in {
  322.     __u32    size;
  323.     __u32    flags;
  324. };
  325.  
  326. struct fuse_getxattr_in {
  327.     __u32    size;
  328.     __u32    padding;
  329. };
  330.  
  331. struct fuse_getxattr_out {
  332.     __u32    size;
  333.     __u32    padding;
  334. };
  335.  
  336. struct fuse_lk_in {
  337.     __u64    fh;
  338.     __u64    owner;
  339.     struct fuse_file_lock lk;
  340.     __u32    lk_flags;
  341.     __u32    padding;
  342. };
  343.  
  344. struct fuse_lk_out {
  345.     struct fuse_file_lock lk;
  346. };
  347.  
  348. struct fuse_access_in {
  349.     __u32    mask;
  350.     __u32    padding;
  351. };
  352.  
  353. struct fuse_init_in {
  354.     __u32    major;
  355.     __u32    minor;
  356.     __u32    max_readahead;
  357.     __u32    flags;
  358. };
  359.  
  360. struct fuse_init_out {
  361.     __u32    major;
  362.     __u32    minor;
  363.     __u32    max_readahead;
  364.     __u32    flags;
  365.     __u32    unused;
  366.     __u32    max_write;
  367. };
  368.  
  369. struct fuse_interrupt_in {
  370.     __u64    unique;
  371. };
  372.  
  373. struct fuse_bmap_in {
  374.     __u64    block;
  375.     __u32    blocksize;
  376.     __u32    padding;
  377. };
  378.  
  379. struct fuse_bmap_out {
  380.     __u64    block;
  381. };
  382.  
  383. struct fuse_in_header {
  384.     __u32    len;
  385.     __u32    opcode;
  386.     __u64    unique;
  387.     __u64    nodeid;
  388.     __u32    uid;
  389.     __u32    gid;
  390.     __u32    pid;
  391.     __u32    padding;
  392. };
  393.  
  394. struct fuse_out_header {
  395.     __u32    len;
  396.     __s32    error;
  397.     __u64    unique;
  398. };
  399.  
  400. struct fuse_dirent {
  401.     __u64    ino;
  402.     __u64    off;
  403.     __u32    namelen;
  404.     __u32    type;
  405.     char name[0];
  406. };
  407.  
  408. #define FUSE_NAME_OFFSET offsetof(struct fuse_dirent, name)
  409. #define FUSE_DIRENT_ALIGN(x) (((x) + sizeof(__u64) - 1) & ~(sizeof(__u64) - 1))
  410. #define FUSE_DIRENT_SIZE(d) \
  411.     FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET + (d)->namelen)
  412.